package com.bianqian.demo.service;

import com.bianqian.demo.entity.User;
import com.bianqian.demo.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Optional;

/**
 * 用户服务层
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class UserService {
    
    private final UserRepository userRepository;
    
    /**
     * 用户注册
     * @param nickname 昵称
     * @param account 账号
     * @param password 密码
     * @return 注册的用户信息
     * @throws RuntimeException 如果账号已存在
     */
    @Transactional
    public User register(String nickname, String account, String password) {
        log.info("开始注册用户，账号：{}", account);
        
        // 检查账号是否已存在
        if (userRepository.existsByAccount(account)) {
            log.warn("账号已存在：{}", account);
            throw new RuntimeException("账号已存在");
        }
        
        // 创建新用户
        User user = new User();
        user.setNickname(nickname);
        user.setAccount(account);
        user.setPassword(password); // 实际项目中应该加密密码
        user.setAvatar("https://example.com/default-avatar.jpg"); // 默认头像
        
        User savedUser = userRepository.save(user);
        log.info("用户注册成功，ID：{}", savedUser.getId());
        
        return savedUser;
    }
    
    /**
     * 用户登录
     * @param account 账号
     * @param password 密码
     * @return 用户信息
     * @throws RuntimeException 如果账号或密码错误
     */
    public User login(String account, String password) {
        log.info("开始用户登录，账号：{}", account);
        
        Optional<User> userOpt = userRepository.findByAccount(account);
        if (!userOpt.isPresent()) {
            log.warn("账号不存在：{}", account);
            throw new RuntimeException("账号或密码错误");
        }
        
        User user = userOpt.get();
        if (!password.equals(user.getPassword())) { // 实际项目中应该比较加密后的密码
            log.warn("密码错误，账号：{}", account);
            throw new RuntimeException("账号或密码错误");
        }
        
        log.info("用户登录成功，ID：{}", user.getId());
        return user;
    }
    
    /**
     * 根据ID查找用户
     * @param id 用户ID
     * @return 用户信息
     */
    public Optional<User> findById(Long id) {
        return userRepository.findById(id);
    }
    
    /**
     * 更新用户信息
     * @param userId 用户ID
     * @param nickname 昵称
     * @param phone 手机号
     * @param avatar 头像
     * @return 更新后的用户信息
     */
    @Transactional
    public User updateProfile(Long userId, String nickname, String phone, String avatar, String insurancePassword) {
        log.info("开始更新用户信息，用户ID：{}", userId);
        
        Optional<User> userOpt = userRepository.findById(userId);
        if (!userOpt.isPresent()) {
            log.warn("用户不存在，ID：{}", userId);
            throw new RuntimeException("用户不存在");
        }
        
        User user = userOpt.get();
        
        if (nickname != null && !nickname.trim().isEmpty()) {
            user.setNickname(nickname.trim());
        }
        if (phone != null) {
            user.setPhone(phone.trim().isEmpty() ? null : phone.trim());
        }
        if (avatar != null) {
            user.setAvatar(avatar.trim().isEmpty() ? null : avatar.trim());
        }
        if (insurancePassword != null) {
            user.setInsurancePassword(insurancePassword.trim().isEmpty() ? null : insurancePassword.trim());
        }
        
        User updatedUser = userRepository.save(user);
        log.info("用户信息更新成功，ID：{}", updatedUser.getId());
        
        return updatedUser;
    }
    
    /**
     * 删除用户账号
     * @param userId 用户ID
     */
    @Transactional
    public void deleteUser(Long userId) {
        log.info("开始删除用户账号，用户ID：{}", userId);
        
        if (!userRepository.existsById(userId)) {
            log.warn("用户不存在，ID：{}", userId);
            throw new RuntimeException("用户不存在");
        }
        
        userRepository.deleteById(userId);
        log.info("用户账号删除成功，ID：{}", userId);
    }

    /**
     * 设置保险箱密码（明文演示，生产建议保存哈希）
     */
    @Transactional
    public User setInsurancePassword(Long userId, String password) {
        Optional<User> userOpt = userRepository.findById(userId);
        if (!userOpt.isPresent()) {
            throw new RuntimeException("用户不存在");
        }
        User user = userOpt.get();
        user.setInsurancePassword(password == null || password.trim().isEmpty() ? null : password.trim());
        return userRepository.save(user);
    }
}
